COMMENT ⊗   VALID 00002 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	!!!how to make biblio. make PUB macro to build page refs in biblio telling
C00019 ENDMK
C⊗;
!!!how to make biblio. make PUB macro to build page refs in biblio telling
where ref is used. give synopsis of contents of eaach reference.

COMPARISON  LISP- λ-CALS λX2 IS 2 IN λ-CALC

GIVE INTUITION OF Y AS COMBINATOR

DEVELOP REDUCTION RULES A'LA λ-CALC; MOTIVATE FROM SECTION ON λ-CAL
BY SHOWING PROGMATICS OF λ-RED.

add equality and defined predicates, perhaps as problems.MAL p34.

add MAL's comment on evcon e.g. eval on
(COND((QUOTE X)(QUOTE X))((QUOTE T)(QUOTE T))
yeilds T ather than undefined.  probably add as problem
compare definition on lisp 1.5 man v.s. necessity of composition

add relationship between notation-denotation and concrete-abstract
den(not(x)≡x  car(cons(x,y))≡ x   cf MAL p46.

add intuitive continuous, monotonic 
		*and strict

ADD FIXPOINTING ON DATA TYPES; E.G. SEXPR = ATOM ∪ SEXPR

		**NOTE: MATHEMATICAL MEANING IS MORE BASIC THAN MANIPULATIVE MENAING; 
OP VS. DEN CF TRUTH VS. PROVABILITY D.SCOTT )
		*LISP EAN PL EXPRESSIONS HAAVE MENAING INDEPENDENT OF RULES OF CALC.

COMPARE D.PARK SHOW Y=Y' VIA SCOTT THOUGH NOT SAME NORMAL FORM

ADD BS IN INTRO ABOUT SCOTT

		*GOOD EXAMPLE OF DENOT VS. OP
		*F = λ(N)(N=0 → 0, F(N-1) + 2N -1
		*OPERATION OF EVLAUATION FOR SAMPLE ARGS F(0), F(1),...IS REALLY  HUNTING FOR LIMIT
		*OF SEQUENCE OF FUNCTIONS FIST TOTALLY UNK THE ON2 VAL, THE 2,...
		*PROCESS USUALLY STOPS WHEN WE SUDDNENLY RELIZE THE DENOTATION IS N↑2.

Must add mathematics of λ-notation in early section and relate to LISP; then
refere to this in Scott section
re above: λ's and machine i.e. copy rule NO order of eval etc( probably wegner and
church)

MUST add better description of global or fluid variable prior to Scott section!!

add graph of function

		*DO INTUITIVE SCOTT ON GM SUBSETS

remark: notice that "real" eval does more than c-b-v in that it looks at the
type of the "function" before evaluating args--fexpr v.s. expr. True
c-b-v  doesn't look at funct. until after  args are evaled.

faces of recursion as described by hewitt and [?]; trying to separate
may help motivate continuatiions.

		*evalquote[fn;args] = f[arg1, ...argn] relates denotational with opereational

		*question for reader:  is λ[x]2 same as λ[]2?

is "value" vs. "meaning" a distinction worth making..probably; see
tennet phd II-22.

		*wadsworth: operational requires specifying too much p.4. cf lisp call by value
		  *and l-r evaluation of args.

		*more on undefined and scott's logic

ADD CONTINUATIONS..

TRY FOR || BETWEEN OLD EVAL, NEW EVAL GENERIC AND ACTORS

	*in section of λ-notation:  note that <= is NOT assignment
	*for  fact <= λ[[x][ ... T→*[x,fact[x-1]]] would say use fact on RHS
	*in assigning  to LHS, and THAT IS WRONG! <= is fixed po	int.
	*c.f.  x ← -(2x+1)/x and x = -(2x+1)/x. first has value dependent on current value
	of x. second has SOLUTION of x=1. so to with fact above; it has solu*tion, but
	*here solution is a function rather than a simpl	e value.
	*introduce through example:
	g←λy.y+1
	f←λx.g[x]
	whats f[2]
	g←λy.y-1
	what's f[2]
	*1. if doesn't change, then try fact.lose.
	*2. if does change lose closures.

Quam's suggestions:
1. re tracing and debugging: hack similar ro value cells where sube/fsubr link is
immovable and we pushj through it.

2. more hhs on bignums

what the fuck does abstract data structure mean.
perhaps consider following: definition of lists in LISP wrt to
UR of dp's. input: recog (a b); output: how to print; reognizer: islist;
how to generate; how to select: n(th); 1-4 via SDIO; 1-2 external; 3-5 internal.


look at old 7090 lisp compr

add abstract compiler

		*note in sdio and in debugging sdio's importance for debugging
		*you can read it!!

		*another reason for removing go to and label. when writing a smart compiler
		*much can be saved by remembering what is where(in which ac's] note
		*how much of lisp complier is getting registers set up.
		*code at label can be approached from any go to. so we must try
		*to remember whether every approach has same setting of reg; only then can we
		*optimize; give example; remove go to and label and problem goes away.


DEEP BINDING COMPILER !!!!! AND PROOF A'LA LONDON
    NOTE THAT DEEP BIN COMP HAS NAMES ON STACK SHALL DOESN'T..BUT CAN BE FIXED
    GOOD FOR DEBUGGING

NOTE FUNCTION WILL COMPILE CODE USUSALLY WHEREAS QUOTE WON'T.

		*ABSTRACT EVAL AND CO  SHOWING FUNARG AS PER WEIZENBAUM

		**arg about deep binding and searching stack: loop is expensive ; 
		**therefore another reason to keep iteration in language and away from programmer
		**(i.e. no go to's) since then  can be "smart" about access....should be
		**able to do something about  "fast memory" in such case

arg two: bobrow's claim that functon names are global; if i reassign defintion
for function, say "car" it is local in strongest sense rather than global.

add syntax of progs

		*somewhere...we shall be interested in ideas not coding tricks

section on types of binding perhaps: value, ref, uneval , name, ...AND BINDING
  BY PATTERN: PDI

bruce's comments
		*1. say what "undefined" means in implementation
		*    should ref implementation when undefined is first mentioned, but put later
		**2. separation of rep from algorithm
3. doesn't like special forms.. justify
4. more examples of func. args.  show lossage on closure.
		*5. doesn't like shallow binding and func. args.
6. circularity and d.scott
		*7. handling of calling w.o. ac's i.e. 1.5 imp
8. non-trivial for g.c. to search bps....true
9. wants hacks in bbn lisp exposed
10. suggest some kind of indirection for callin function args..prob poor
11. doesn't believe bit map necessary for more complex data structure marking.
12. moron dope vector

		*check basel on free vars in procedure assignments

		*check if we have noted that outlawing globals woulf f.u. function names
		*(which ARE  globals)

		*add  handling of funargs with shallow binder in binding revisited.

		*add selectq as a prob compare to case statement

		* on function v.s. form cf. λ[]x+y  vs x+y
		*ON CLOSED VS OPEN

		*ALTERNATIVE CALLING IN STACK RATHER THAN AC'S

		**note on SM-eval: if car of form is not atomic then it is assumed to be
		**reducible to a function (NOT fexpr) i.e. it evals arg. tsk,tsk.
		**related problem: can eval and co. be changed to not be so precipitous about
		**evaluating args.
		**then there's the nlambda horse shit....

		*hlisp eval with types

		**but in explicit discussion of functions: fixed # of args in definition and call
		**in fact  in section showing equal[A;A] or what ever

		**probelm:  predecessor 

		**explicit thaat f[a1; ...an] is apply[F a1' ....an'; st of a	ll called non prim funcst]

should show explicitly stack picture of returns on stack
do in parallel with coutour...i.e. in columns

		*(LAMBDA(LAMBDA) ...) AFTER NEW SYM TAB 
		*OR  prog[x;y]    ......x← y;    x:      ....go [x]
		*either of above for multiplcity of props.

NEED SECTION ON READ HACKERY...INTERN READLIST  EXPLODE

		*EXTENSIVE SECTIONS ON BINDING SHALLOW DEEP HACKERY

EXTENSIONS OF LISP A LA PLANNER DATA BASES PATT MATCH..
PATTERN DIRECTED INNVOC

		*WEIZENBAUM ON CONTROL BOBROW-WEG

MAPPING OF CONTOUR TO STACK MODEL

MACHINES 

		*QUAMS SDIO MLISP2  H.S.


how about multiple values reutrnrd s.t. function with mult args can get

shoW eval doesn't have to search oblist to find atom..done by read

		**MOVE FEXPR-MACRO SECTION TO AREA OF SM-EVAL

		**PROBLEM OF DIRECT REVERS W.O. APPEND

		add function-form distinction in λ-expr section
		
		put cross ref to form where bnf is described  for form

		COMMENT: ADD BOYER-MOORE TO PROOF SECTION, AND BIBLIO

PROBLEM IN 3.9 VALUE IN SYMTAB

		IN MACRO: WHY BETTER THAN SUBR...MORE EFFICIENT OPEN CODED BUT CAN
		BE INTUITIVE NOTATION...CF POLY EXAMPLE

		**PROBLEM IN DIFF SECTION : EXTEND TO N-ARY OPS

COMMENT: SAY "IF ARGS ARE ATOMIC..." WE REALLY MEAN "IF VALUE OF ARGS IS ATOMIC...."

		**COMMENT CAR CDR ARE SELECTORS; CONS IS CONSTRUCTOR

PROBLEM: GIVE CAR-CDR TO FIND ATOM IN..


		IN INT NOTES IN 4 SECTIONS: LANG,EVAL,IMP,COMP

ADD FANCY DIFFERENTIATION AFTTER FUN ARGS

		**ADD J. MORRIS EXAMPLE IN PROBLEMS CONCERNING COND AND ORDER
		OF EVAL

		**in list section: cons[x list] (x,    )

		add bumpfh about relative spped and space of compilation .: why not
		compile.. debugging editing...etc.

add problems on efficient compilation,using open car and cdr

		**get going on bibliography

		**ADD PROB OF EVAL FOR CALL BY NAME

IMPLICATIONS OF LISP TO OTHER LANGUAGES  COMPILING BETTER SINCE
MUCH KNOWN AT COMPILE TIME ETC. PARISNG  ETC

		**bootstrapping for chrissakes!!!!!

		**add problem in applic. of rpacac  for ratom

		**reference counters

		**crap on committee effect

notes on c e quote from test

		**define FEXPR, SUBR, EXPR FSUBR 

		*PICTURES .STRUCTURE OF FACT
		*	OBLIST
		*	NIL
		*	BIN AND UNBIND
		*	AMBIT GC
		* 	AMBIT PRIMITIVES

		**tiltle super lisp to be published by mung,manure and sun, the organic pub  co.

		**explain NIl vs evwrything else in cestrin on implemenasion--where eq x;x is given

		** problem for rplacd: rplacd x;cdr x is?

		**PROB INPROGS: EXTEND EVAL TO PROG

		**prob in progs extensions a la muddle conniver
		initialization of aux; optional, tuple eval unevaled args
		check if micro-plnr allows initialized aux.

		**much more on lambdda and internal lambdas and uses.

		**add arrays

fart with funarg and functional args: weizenbaum
INCLUDE MULTIPLE OBLISTS HERE ON S.T. DISCUSSION
note collision problem of say compiler loacals with user thus muli sym.

		**add BNF for functions near front

		**add fexpr-fsubr discussion in new eval and into discussion of how to compile

		**MORE ON NUMBERS IN FIRST SECTION

		**ADD VALUE CELL DEPRESSION, PNAME TOO

		*add LISP version of gc a la exam to secion on AMBIT

		**add calling conventions to simple pdp-10 section 6.12

more examples on machine

		**equivalence of length reverse append

		**need to add full assembler somewhere

		**add problem of Jorge: function bringing back dotted pair of
		**info found in arbit. tree.

		**hs. on semantics added to front of  compilation hs.

		**table driven scanner and parser **table driven in progs


		**and and or into compiler?

		**add E to description of assemble

		**add C as well

		**ADD SKETCH OF COMPILATION OF F = J G(X)H(Y) 

		**multiple car-cdrs and lists 1st.2nd etc

		**hash consing

errset, catch and throw

multiple oblists

		**read muddle manual again

readlist intern

i/o channels

bbn lisp editor and debugger